

class OutrClass {
    public int date1 = 10;
    public int date2 = 20;
    public int date3 = 30;

    //实例内部类
    class InnerClass {
        //实例内部类对象只有在外部类对象先创建后才能创建实例内部类对象
        public int date4 = 40;
        private int date5 = 50;
        public int date1 = 100;

        //在实例内部类当中不能够定义静态变量
        public static final int date6 = 60;
        //不加static就不行，因为static不依赖对象
        //但是加了final修饰就可以了，是因为final修饰的常量 常量是在编译的时候就已经确定了

        public void testInner() {
            System.out.println("testInner");
            System.out.println(OutrClass.this.date1);
            //外部类类名.this.变量  就可以访问外部类的变量
            System.out.println(date1);
            //变量名相同时优先访问内部类自己的
            System.out.println(date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);

            //能够定义普通方法
        }
    }

    public void testOut() {
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.date1);
        //外部类中 访问内部类的成员要先创建内部类的对象，再用对象去访问（因为内部类也是一个类）
    }
}

class OutrClass2 {
    public int date1 = 10;
    public int date2 = 20;
    public static int date3 = 30;

    static class InnerClass2 {
        //这个就是一个静态内部类
        public int date4 = 40;
        private int date5 = 50;
        public static int date6 = 60;

        public void testInner() {
            System.out.println("testInner()");
            /*System.out.println(OutrClass2.this.date1);//这个是不能够去访问的，因为再静态类当中是不包含this的*/
            OutrClass2 outrClass2 = new OutrClass2();
            System.out.println(outrClass2.date1);
            System.out.println(outrClass2.date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);

        }
    }

}

class OuterClass3 {
    public void test() {
        class Inner {
            public int date1 = 10;
        }
        Inner inner = new Inner();
        System.out.println(inner.date1);
        //只能在当前位置实例化

    }
}

interface Shape {
    void draw();
}
class Student implements Comparable<Student>{

    @Override
    public int compareTo(Student o) {
        return 0;
    }

}

public class Test {
    public static void main(String[] args) {
        Comparable<Student> comparable = new Student();

        /*new Comparable<Student>(){
            @Override
            public int compareTo(Student o) {
                return 0;
                //这个就是我们是实现了一个接口，并且重写了方法，但是我们不清楚是哪个类去实现的接口
                //这个实现的接口就是匿名内部类
            }
        };*/

        int a = 10;
        new Shape() {
            //a = 99;// 在匿名内部类当中访问的变量是不可以改变的
            @Override
            public void draw() {
                System.out.println("矩形" + a);
            }
        }.draw();
    }
    public static void main2(String[] args) {
        OutrClass2.InnerClass2 innerClass = new OutrClass2.InnerClass2();
        //静态内部类不需要外部类对象可以直接进行实例化,不需要外部类对象
        innerClass.testInner();

    }




    public static void main1(String[] args) {
        //实例化内部类
        //通过外部类去实例化内部类
        /*OutrClass outrClass = new OutrClass();
        OutrClass.InnerClass innerClass = outrClass.new InnerClass();*/
        //外部类.内部类 引用名 = 外部类.new 内部类对象    前提：必选先实例化外部类
        OutrClass.InnerClass innerClass = new OutrClass().new InnerClass();//与上面两行代码相同
        innerClass.testInner();

    }
}
